namespace ext
{
	using System;
	using System.Runtime.CompilerServices;
	using System.Html;
	using System.Collections;
	
	
	/// <summary>
	/// Applies drag handles to an element to make it resizable. The drag handles are inserted into the element
	/// and positioned absolute. Some elements, such as a textarea or image, don&apos;t support this. To overcome that, you can wrap
	/// the textarea in a div and set &apos;resizeChild&apos; to true (or to the id of the element), or set wrap:true in your config and
	/// the element will be wrapped for you automatically.  Here is the list of valid resize handles:  
	/// Value Description
	/// ------ -------------------
	/// &apos;n&apos; north
	/// &apos;s&apos; south
	/// &apos;e&apos; east
	/// &apos;w&apos; west
	/// &apos;nw&apos; northwest
	/// &apos;sw&apos; southwest
	/// &apos;se&apos; southeast
	/// &apos;ne&apos; northeast
	/// &apos;all&apos; all
	///  Here&apos;s an example showing the creation of a typical Resizable:  
	/// var resizer = new Ext.Resizable(&apos;element-id&apos;, {
	/// handles: &apos;all&apos;,
	/// minWidth: 200,
	/// minHeight: 100,
	/// maxWidth: 500,
	/// maxHeight: 400,
	/// pinned: true
	/// });
	/// resizer.on(&apos;resize&apos;, myHandler);
	///  To hide a particular handle, set its display to none in CSS, or through script:
	/// </summary>
	/// <htmlSummary>
	/// &lt;p&gt;Applies drag handles to an element to make it resizable. The drag handles are inserted into the element
	/// and positioned absolute. Some elements, such as a textarea or image, don&apos;t support this. To overcome that, you can wrap
	/// the textarea in a div and set &apos;resizeChild&apos; to true (or to the id of the element), &lt;b&gt;or&lt;/b&gt; set wrap:true in your config and
	/// the element will be wrapped for you automatically.&lt;/p&gt;
	/// &lt;p&gt;Here is the list of valid resize handles:&lt;/p&gt;
	/// &lt;pre&gt;
	/// Value Description
	/// ------ -------------------
	/// &apos;n&apos; north
	/// &apos;s&apos; south
	/// &apos;e&apos; east
	/// &apos;w&apos; west
	/// &apos;nw&apos; northwest
	/// &apos;sw&apos; southwest
	/// &apos;se&apos; southeast
	/// &apos;ne&apos; northeast
	/// &apos;all&apos; all
	/// &lt;/pre&gt;
	/// &lt;p&gt;Here&apos;s an example showing the creation of a typical Resizable:&lt;/p&gt;
	/// &lt;pre&gt;&lt;code&gt;
	/// var resizer = new Ext.Resizable(&apos;element-id&apos;, {
	/// handles: &apos;all&apos;,
	/// minWidth: 200,
	/// minHeight: 100,
	/// maxWidth: 500,
	/// maxHeight: 400,
	/// pinned: true
	/// });
	/// resizer.on(&apos;resize&apos;, myHandler);
	/// &lt;/code&gt;&lt;/pre&gt;
	/// &lt;p&gt;To hide a particular handle, set its display to none in CSS, or through script:&lt;br&gt;
	/// resizer.east.setDisplayed(false);&lt;/p&gt;
	/// </htmlSummary>
	/// <definedin>src\widgets\Resizable.js</definedin>
	[ScriptName("Resizable")]
	[ScriptNamespace("Ext")]
	[Imported()]
	public partial class Resizable : ext.util.Observable
	{
		
		#region Constructors
		/// <summary>Constructor</summary>
		/// <param name="el">The id or element to resize</param>
		/// <param name="config">configuration options</param>
		public Resizable(object el, ext.Resizable_Configuration config)
		{
		}
		
		/// <summary>Constructor</summary>
		public Resizable()
		{
		}
		#endregion
		
		#region Fields
		/// <summary>Fired before resize is allowed. Set {@link #enabled} to false to cancel resize.</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("beforeresizeEventName")]
		public const string BeforeresizeEventName = "beforeresize";
		
		/// <summary>Fired after a resize.</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("resizeEventName")]
		public const string ResizeEventName = "resize";
		
		/// <summary>
		/// String &apos;auto&apos; or an array [width, height] with values to be added to the
		/// resize operation&apos;s new size (defaults to [0, 0])
		/// </summary>
		/// <htmlSummary>
		/// String &apos;auto&apos; or an array [width, height] with values to be &lt;b&gt;added&lt;/b&gt; to the
		/// resize operation&apos;s new size (defaults to &lt;tt&gt;[0, 0]&lt;/tt&gt;)
		/// </htmlSummary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("adjustments")]
		public ext.auto.System_String_Or_System_Array Adjustments;
		
		/// <summary>True to animate the resize (not compatible with dynamic sizing, defaults to false)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("animate")]
		public bool Animate;
		
		/// <summary>Constrain the resize to a particular element</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("constrainTo")]
		public object ConstrainTo;
		
		/// <summary>True to disable mouse tracking. This is only applied at config time. (defaults to false)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("disableTrackOver")]
		public bool DisableTrackOver;
		
		/// <summary>Convenience to initialize drag drop (defaults to false)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("draggable")]
		public bool Draggable;
		
		/// <summary>Animation duration if animate = true (defaults to 0.35)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("duration")]
		public System.Number Duration;
		
		/// <summary>True to resize the element while dragging instead of using a proxy (defaults to false)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("dynamic")]
		public bool Dynamic;
		
		/// <summary>Animation easing if animate = true (defaults to &apos;easingOutStrong&apos;)</summary>
		/// <htmlSummary>Animation easing if animate = true (defaults to &lt;tt&gt;&apos;easingOutStrong&apos;&lt;/tt&gt;)</htmlSummary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("easing")]
		public string Easing;
		
		/// <summary>False to disable resizing (defaults to true)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("enabled")]
		public bool Enabled;
		
		/// <summary>
		/// String consisting of the resize handles to display (defaults to undefined).
		/// Specify either &apos;all&apos; or any of &apos;n s e w ne nw se sw&apos;.
		/// </summary>
		/// <htmlSummary>
		/// String consisting of the resize handles to display (defaults to undefined).
		/// Specify either &lt;tt&gt;&apos;all&apos;&lt;/tt&gt; or any of &lt;tt&gt;&apos;n s e w ne nw se sw&apos;&lt;/tt&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("handles")]
		public string Handles;
		
		/// <summary>Deprecated. Deprecated style of adding multi-direction resize handles.</summary>
		/// <htmlSummary>&lt;b&gt;Deprecated&lt;/b&gt;. Deprecated style of adding multi-direction resize handles.</htmlSummary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("multiDirectional")]
		public bool MultiDirectional;
		
		/// <summary>The height of the element in pixels (defaults to null)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("height")]
		public System.Number Height;
		
		/// <summary>The width of the element in pixels (defaults to null)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("width")]
		public System.Number Width;
		
		/// <summary>
		/// The increment to snap the height resize in pixels
		/// (only applies if {@link #dynamic}==true). Defaults to 0.
		/// </summary>
		/// <htmlSummary>
		/// The increment to snap the height resize in pixels
		/// (only applies if &lt;code&gt;{@link #dynamic}==true&lt;/code&gt;). Defaults to &lt;tt&gt;0&lt;/tt&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("heightIncrement")]
		public System.Number HeightIncrement;
		
		/// <summary>
		/// The increment to snap the width resize in pixels
		/// (only applies if {@link #dynamic}==true). Defaults to 0.
		/// </summary>
		/// <htmlSummary>
		/// The increment to snap the width resize in pixels
		/// (only applies if &lt;code&gt;{@link #dynamic}==true&lt;/code&gt;). Defaults to &lt;tt&gt;0&lt;/tt&gt;.
		/// </htmlSummary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("widthIncrement")]
		public System.Number WidthIncrement;
		
		/// <summary>The minimum height for the element (defaults to 5)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("minHeight")]
		public System.Number MinHeight;
		
		/// <summary>The minimum width for the element (defaults to 5)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("minWidth")]
		public System.Number MinWidth;
		
		/// <summary>The maximum height for the element (defaults to 10000)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("maxHeight")]
		public System.Number MaxHeight;
		
		/// <summary>The maximum width for the element (defaults to 10000)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("maxWidth")]
		public System.Number MaxWidth;
		
		/// <summary>The minimum x for the element (defaults to 0)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("minX")]
		public System.Number MinX;
		
		/// <summary>The minimum x for the element (defaults to 0)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("minY")]
		public System.Number MinY;
		
		/// <summary>
		/// True to ensure that the resize handles are always visible, false to display them only when the
		/// user mouses over the resizable borders. This is only applied at config time. (defaults to false)
		/// </summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("pinned")]
		public bool Pinned;
		
		/// <summary>
		/// True to preserve the original ratio between height
		/// and width during resize (defaults to false)
		/// </summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("preserveRatio")]
		public bool PreserveRatio;
		
		/// <summary>True to resize the first child, or id/element to resize (defaults to false)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("resizeChild")]
		public ext.auto.System_Boolean_Or_System_String_Or_ext_Element ResizeChild;
		
		/// <summary>True for transparent handles. This is only applied at config time. (defaults to false)</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("transparent")]
		public bool Transparent;
		
		/// <summary>Constrain the resize to a particular region</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("resizeRegion")]
		public ext.lib.Region ResizeRegion;
		
		/// <summary>
		/// True to wrap an element with a div if needed (required for textareas and images, defaults to false)
		/// in favor of the handles config option (defaults to false)
		/// </summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("wrap")]
		public bool Wrap;
		
		/// <summary>A css class to add to each handle. Defaults to &apos;&apos;.</summary>
		/// <htmlSummary>A css class to add to each handle. Defaults to &lt;tt&gt;&apos;&apos;&lt;/tt&gt;.</htmlSummary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("handleCls")]
		public string HandleCls;
		#endregion
		
		#region Properties
		/// <summary>
		/// The proxy Element that is resized in place of the real Element during the resize operation.
		/// This may be queried using {@link Ext.Element#getBox} to provide the new area to resize to.
		/// Read only.
		/// </summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("proxy")]
		[IntrinsicProperty()]
		public ext.Element Proxy
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		
		/// <summary>Writable. False if resizing is disabled.</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("enabled")]
		[IntrinsicProperty()]
		public bool EnabledProperty
		{
			get
			{
				throw new System.Exception("Imported - not implemented");
			}
			set
			{
			}
		}
		#endregion
		
		#region Methods
		/// <summary>Perform a manual resize and fires the &apos;resize&apos; event.</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		/// <param name="width"></param>
		/// <param name="height"></param>
		[ScriptName("resizeTo")]
		public void ResizeTo(System.Number width, System.Number height)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Performs resizing of the associated Element. This method is called internally by this
		/// class, and should not be called by user code.  If a Resizable is being used to resize an Element which encapsulates a more complex UI
		/// component such as a Panel, this method may be overridden by specifying an implementation
		/// as a config option to provide appropriate behaviour at the end of the resize operation on
		/// mouseup, for example resizing the Panel, and relaying the Panel&apos;s content.  The new area to be resized to is available by examining the state of the {@link #proxy}
		/// Element. Example:
		/// 
		/// new Ext.Panel({
		/// title: &apos;Resize me&apos;,
		/// x: 100,
		/// y: 100,
		/// renderTo: Ext.getBody(),
		/// floating: true,
		/// frame: true,
		/// width: 400,
		/// height: 200,
		/// listeners: {
		/// render: function(p) {
		/// new Ext.Resizable(p.getEl(), {
		/// handles: &apos;all&apos;,
		/// pinned: true,
		/// transparent: true,
		/// resizeElement: function() {
		/// var box = this.proxy.getBox();
		/// p.updateBox(box);
		/// if (p.layout) {
		/// p.doLayout();
		/// }
		/// return box;
		/// }
		/// });
		/// }
		/// }
		/// ..
		/// </summary>
		/// <htmlSummary>
		/// &lt;p&gt;Performs resizing of the associated Element. This method is called internally by this
		/// class, and should not be called by user code.&lt;/p&gt;
		/// &lt;p&gt;If a Resizable is being used to resize an Element which encapsulates a more complex UI
		/// component such as a Panel, this method may be overridden by specifying an implementation
		/// as a config option to provide appropriate behaviour at the end of the resize operation on
		/// mouseup, for example resizing the Panel, and relaying the Panel&apos;s content.&lt;/p&gt;
		/// &lt;p&gt;The new area to be resized to is available by examining the state of the {@link #proxy}
		/// Element. Example:
		/// &lt;pre&gt;&lt;code&gt;
		/// new Ext.Panel({
		/// title: &apos;Resize me&apos;,
		/// x: 100,
		/// y: 100,
		/// renderTo: Ext.getBody(),
		/// floating: true,
		/// frame: true,
		/// width: 400,
		/// height: 200,
		/// listeners: {
		/// render: function(p) {
		/// new Ext.Resizable(p.getEl(), {
		/// handles: &apos;all&apos;,
		/// pinned: true,
		/// transparent: true,
		/// resizeElement: function() {
		/// var box = this.proxy.getBox();
		/// p.updateBox(box);
		/// if (p.layout) {
		/// p.doLayout();
		/// }
		/// return box;
		/// }
		/// });
		/// }
		/// }
		/// }).show();
		/// &lt;/code&gt;&lt;/pre&gt;
		/// </htmlSummary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("resizeElement")]
		public void ResizeElement()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the element this component is bound to.</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("getEl")]
		public ext.Element GetEl()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>Returns the resizeChild element (or null).</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("getResizeChild")]
		public ext.Element GetResizeChild()
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Destroys this resizable. If the element was wrapped and
		/// removeEl is not true then the element remains.
		/// </summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		/// <param name="removeEl">true to remove the element from the DOM</param>
		[ScriptName("destroy")]
		public void Destroy(bool removeEl)
		{
			throw new System.Exception("Imported - not implemented");
		}
		
		/// <summary>
		/// Destroys this resizable. If the element was wrapped and
		/// removeEl is not true then the element remains.
		/// </summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("destroy")]
		public void Destroy()
		{
			throw new System.Exception("Imported - not implemented");
		}
		#endregion
		
		#region Events
		/// <summary>Fired before resize is allowed. Set {@link #enabled} to false to cancel resize.</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("beforeresize")]
		public event ext.auto.Delegate_ext_Resizable_And_ext_EventObject Beforeresize;
		
		/// <summary>Fired after a resize.</summary>
		/// <definedin>src\widgets\Resizable.js</definedin>
		[ScriptName("resize")]
		public event ext.auto.Delegate_ext_Resizable_And_System_Number_And_System_Number_And_ext_EventObject Resize;
		#endregion
	}
}
